package com.resume.aipeople.service.ai.model;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * LLM模型管理器
 * 负责管理不同的LLM模型策略
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class LLMModelManager {
    
    private final Map<String, LLMModelStrategy> modelStrategies = new HashMap<>();
    private String currentModel = "gemini-2.5-flash"; // 默认使用Gemini，更适合角色扮演
    
    /**
     * 注册模型策略
     * @param strategy 模型策略
     */
    public void registerModelStrategy(LLMModelStrategy strategy) {
        modelStrategies.put(strategy.getModelName(), strategy);
        log.info("注册LLM模型策略: {} - {}", strategy.getModelName(), strategy.getDisplayName());
    }
    
    /**
     * 获取当前模型策略
     * @return 当前模型策略
     */
    public LLMModelStrategy getCurrentModelStrategy() {
        LLMModelStrategy strategy = modelStrategies.get(currentModel);
        if (strategy == null) {
            log.warn("当前模型 {} 不存在，使用默认模型", currentModel);
            // 优先选择Gemini，其次GLM
            strategy = modelStrategies.get("gemini-2.5-flash");
            if (strategy == null) {
                strategy = modelStrategies.get("GLM-4.5");
            }
            if (strategy == null) {
                strategy = modelStrategies.get("glm-4");
            }
            if (strategy == null) {
                throw new RuntimeException("没有可用的LLM模型");
            }
        }
        return strategy;
    }
    
    /**
     * 切换模型
     * @param modelName 模型名称
     * @return 是否切换成功
     */
    public boolean switchModel(String modelName) {
        if (modelStrategies.containsKey(modelName)) {
            LLMModelStrategy strategy = modelStrategies.get(modelName);
            if (strategy.isAvailable()) {
                currentModel = modelName;
                log.info("切换到LLM模型: {} - {}", modelName, strategy.getDisplayName());
                return true;
            } else {
                log.warn("模型 {} 不可用", modelName);
                return false;
            }
        } else {
            log.warn("模型 {} 不存在", modelName);
            return false;
        }
    }
    
    /**
     * 获取当前模型名称
     * @return 当前模型名称
     */
    public String getCurrentModel() {
        return currentModel;
    }
    
    /**
     * 获取当前模型显示名称
     * @return 当前模型显示名称
     */
    public String getCurrentModelDisplayName() {
        LLMModelStrategy strategy = getCurrentModelStrategy();
        return strategy.getDisplayName();
    }
    
    /**
     * 获取所有可用模型
     * @return 所有可用模型列表
     */
    public List<LLMModelInfo> getAvailableModels() {
        return modelStrategies.values().stream()
                .filter(LLMModelStrategy::isAvailable)
                .map(strategy -> new LLMModelInfo(
                        strategy.getModelName(),
                        strategy.getDisplayName(),
                        strategy.getDescription(),
                        strategy.getModelName().equals(currentModel)
                ))
                .collect(Collectors.toList());
    }
    
    /**
     * 模型信息类
     */
    public static class LLMModelInfo {
        private final String modelName;
        private final String displayName;
        private final String description;
        private final boolean isCurrent;
        
        public LLMModelInfo(String modelName, String displayName, String description, boolean isCurrent) {
            this.modelName = modelName;
            this.displayName = displayName;
            this.description = description;
            this.isCurrent = isCurrent;
        }
        
        public String getModelName() {
            return modelName;
        }
        
        public String getDisplayName() {
            return displayName;
        }
        
        public String getDescription() {
            return description;
        }
        
        public boolean isCurrent() {
            return isCurrent;
        }
    }
}
